“MRU caching,” where MRU stands for “most recently used,” is a known concept for implementing a client-side memory in a client-server system. It is assumed that the server has access to and can serve to a client a large number of data objects, which in the aggregate may occupy a large amount of memory. The available bandwidth between client and server is limited, however, so client requests for data objects to be sent from the server take time. If access to data objects is reasonably “coherent,” meaning that objects which the client needed recently are likely to be needed again in the near future, then MRU caching may increase the efficiency of the client-server system. Employing this approach, the client generally sets aside some limited amount of memory (generally much less than would be needed to store all of the objects on the server), and stores in this memory (a cache) as many of the most recently requested objects as will fit. When a new object is sent from the server to the client and the client's cache space has run out, the least recently used (LRU) object is erased from the cache to create data storage space in which the new object may be stored.
Generally, when the client needs a data object, the cache is first examined to see if the object is cached. If it is cached, then the cached representation is used, obviating the need for a slow or computationally expensive server request. Usually, making use of a cached representation also “promotes” that object to the MRU end of the cache. This approach generally provides substantial performance advantages over having to request data from the server for every data object accessed.
The erasure of the least recently used object from a cache when a new object is accessed by a computing system and stored in the cache may cause inefficiency in cache usage. Even the erased, least-recently-used object in the cache may be again requested by the server. When this happens, the server may undertake the relatively slow or computationally expensive task of retrieving this object from a more remote source of data storage, such as a main memory or mass storage device. Given the finite size of cache memories, object erasure may occur with some frequency, thereby causing a server or other computing system to expend significant resources accessing more remote memories to get data that was once conveniently stored in a cache memory. Accordingly, there is a need in the art for a more efficient and flexible approach to cache memory management.